const dayjs = require('dayjs');
/**
 * 研发项目分支管理模块
 * 负责处理研发项目的分支管理、版本控制等功能
 */

// 引入辅助工具
const cloudHelper = require('./helpers/cloud_helper.js');
const pageHelper = require('./helpers/page_helper.js');
const timeHelper = require('./helpers/time_helper.js');

// 引入业务逻辑
const ProjectBranchBiz = require('../../../config/path_resolver.js').pageHelper;

/**
 * 分支管理器类
 * 用于处理研发项目的分支管理和版本控制
 */
class BranchManager {
  /**
   * 构造函数
   * @param {Object} page - 页面实例
   */
  constructor(page) {
    this.page = page;
    this.cacheTime = 5 * 60 * 1000; // 缓存5分钟
    this.branchCache = {};
  }

  /**
   * 获取项目分支列表
   * @param {string} projectId - 项目ID
   * @param {boolean} useCache - 是否使用缓存
   * @returns {Promise<Array>} 分支项目列表
   */
  async getBranchProjects(projectId, useCache = true) {
    if (!projectId) return [];
    
    // 缓存处理
    const cacheKey = `branch_projects_${projectId}`;
    
    if (useCache && this.branchCache[cacheKey] && 
        (dayjs().valueOf() - this.branchCache[cacheKey].time < this.cacheTime)) {
      return this.branchCache[cacheKey].data;
    }

    try {
      // 请求服务器数据
      const params = {
        parentId: projectId
      };
      
      const result = await cloudHelper.callCloudData('research_project/branch_list', params);
      
      // 格式化数据
      if (result && Array.isArray(result)) {
        result.forEach(item => {
          item.RESEARCH_ADD_TIME_DISPLAY = timeHelper.formatDateTime(item.RESEARCH_ADD_TIME);
        });
      }
      
      // 更新缓存
      this.branchCache[cacheKey] = {
        time: dayjs().valueOf(),
        data: result
      };
      
      return result;
    } catch (error) {
      console.error('获取分支项目列表失败', error);
      pageHelper.showError('获取分支项目列表失败');
      return [];
    }
  }

  /**
   * 获取父项目信息
   * @param {string} projectId - 项目ID
   * @returns {Promise<Object>} 父项目信息
   */
  async getParentProject(projectId) {
    if (!projectId) return null;

    try {
      const project = await this._getProjectDetail(projectId);
      
      if (!project || !project.RESEARCH_PARENT_ID) {
        return null;
      }
      
      return this._getProjectDetail(project.RESEARCH_PARENT_ID);
    } catch (error) {
      console.error('获取父项目信息失败', error);
      return null;
    }
  }

  /**
   * 获取项目详情
   * @private
   * @param {string} projectId - 项目ID
   * @returns {Promise<Object>} 项目详情
   */
  async _getProjectDetail(projectId) {
    if (!projectId) return null;

    try {
      const params = {
        id: projectId
      };
      
      const result = await cloudHelper.callCloudData('research_project/detail', params);
      return result;
    } catch (error) {
      console.error('获取项目详情失败', error);
      return null;
    }
  }

  /**
   * 创建分支项目
   * @param {Object} params - 分支创建参数
   * @param {string} params.parentId - 父项目ID
   * @param {string} params.title - 分支标题
   * @param {string} params.desc - 分支描述
   * @returns {Promise<Object>} 创建结果
   */
  async createBranch(params) {
    if (!params || !params.parentId || !params.title) {
      pageHelper.showError('分支创建参数不完整');
      return null;
    }

    try {
      const result = await cloudHelper.callCloudData('research_project/create_branch', params);
      
      // 清除分支缓存
      const cacheKey = `branch_projects_${params.parentId}`;
      if (this.branchCache[cacheKey]) {
        delete this.branchCache[cacheKey];
      }
      
      return result;
    } catch (error) {
      console.error('创建分支项目失败', error);
      pageHelper.showError('创建分支项目失败: ' + error.message);
      return null;
    }
  }

  /**
   * 初始化分支选项
   * @param {Array} branchProjects - 分支项目列表
   * @param {Object} mainProject - 主项目信息
   * @returns {Array} 分支选项列表
   */
  initBranchOptions(branchProjects, mainProject) {
    if (!mainProject) return [];
    
    // 创建主分支选项
    const options = [
      { id: mainProject._id, name: '主分支', project: mainProject }
    ];
    
    // 添加子分支选项
    if (branchProjects && Array.isArray(branchProjects)) {
      branchProjects.forEach(branch => {
        options.push({
          id: branch._id,
          name: branch.RESEARCH_TITLE,
          project: branch
        });
      });
    }
    
    return options;
  }

  /**
   * 加载分支相关的数据
   * @param {string} branchId - 分支ID
   * @returns {Promise<Object>} 分支相关数据
   */
  async loadBranchRelatedData(branchId) {
    if (!branchId) {
      return {
        flowHistory: [],
        resourceVersions: []
      };
    }

    try {
      // 并行加载流程历史和资源版本
      const [flowHistory, resourceVersions] = await Promise.all([
        this._getBranchFlowHistory(branchId),
        this._getBranchResourceVersionList(branchId)
      ]);
      
      return {
        flowHistory,
        resourceVersions
      };
    } catch (error) {
      console.error('加载分支相关数据失败', error);
      return {
        flowHistory: [],
        resourceVersions: []
      };
    }
  }

  /**
   * 获取分支流程历史
   * @private
   * @param {string} branchId - 分支ID
   * @returns {Promise<Array>} 流程历史记录
   */
  async _getBranchFlowHistory(branchId) {
    if (!branchId) return [];

    try {
      const params = {
        projectId: branchId
      };
      
      const result = await cloudHelper.callCloudData('research_project/flow_history', params);
      
      // 处理时间显示
      if (result && Array.isArray(result)) {
        result.forEach(item => {
          item.FLOW_TIME_DISPLAY = timeHelper.formatDateTime(item.FLOW_TIME);
        });
      }
      
      return result;
    } catch (error) {
      console.error('获取分支流程历史失败', error);
      return [];
    }
  }

  /**
   * 获取分支资源版本列表
   * @private
   * @param {string} branchId - 分支ID
   * @returns {Promise<Array>} 资源版本列表
   */
  async _getBranchResourceVersionList(branchId) {
    if (!branchId) return [];

    try {
      const params = {
        projectId: branchId
      };
      
      const result = await cloudHelper.callCloudData('research_project/resource_list', params);
      
      // 处理时间显示
      if (result && Array.isArray(result)) {
        result.forEach(item => {
          item.RESOURCE_ADD_TIME_DISPLAY = timeHelper.formatDateTime(item.RESOURCE_ADD_TIME);
        });
      }
      
      return result;
    } catch (error) {
      console.error('获取分支资源版本列表失败', error);
      return [];
    }
  }

  /**
   * 合并分支到主分支
   * @param {Object} params - 合并参数
   * @param {string} params.branchId - 分支ID
   * @param {string} params.mainId - 主分支ID
   * @param {string} params.mergeNote - 合并说明
   * @returns {Promise<Object>} 合并结果
   */
  async mergeBranch(params) {
    if (!params || !params.branchId || !params.mainId) {
      pageHelper.showError('分支合并参数不完整');
      return null;
    }

    try {
      const result = await cloudHelper.callCloudData('research_project/merge_branch', params);
      
      // 清除缓存
      Object.keys(this.branchCache).forEach(key => {
        if (key.includes(params.mainId) || key.includes(params.branchId)) {
          delete this.branchCache[key];
        }
      });
      
      return result;
    } catch (error) {
      console.error('合并分支失败', error);
      pageHelper.showError('合并分支失败: ' + error.message);
      return null;
    }
  }

  /**
   * 更新分支项目
   * @param {Object} params - 更新参数
   * @param {string} params.id - 分支ID
   * @param {string} params.title - 分支标题
   * @param {string} params.desc - 分支描述
   * @returns {Promise<Object>} 更新结果
   */
  async updateBranch(params) {
    if (!params || !params.id) {
      pageHelper.showError('分支更新参数不完整');
      return null;
    }

    try {
      const result = await cloudHelper.callCloudData('research_project/update_branch', params);
      
      // 清除所有分支缓存（不知道是哪个分支的子分支，所以清除所有）
      this.branchCache = {};
      
      return result;
    } catch (error) {
      console.error('更新分支项目失败', error);
      pageHelper.showError('更新分支项目失败: ' + error.message);
      return null;
    }
  }

  /**
   * 删除分支项目
   * @param {string} branchId - 分支ID
   * @returns {Promise<boolean>} 是否删除成功
   */
  async deleteBranch(branchId) {
    if (!branchId) {
      pageHelper.showError('分支ID不能为空');
      return false;
    }

    try {
      // 先获取分支详情，找到父项目ID
      const branch = await this._getProjectDetail(branchId);
      if (!branch) {
        return false;
      }
      
      const params = {
        id: branchId
      };
      
      pageHelper.showLoading('删除中...');
      
      // 添加空的options参数
      await cloudHelper.callCloud('research_project/delete_branch', params, {});
      
      // 清除缓存
      if (branch.RESEARCH_PARENT_ID) {
        const cacheKey = `branch_projects_${branch.RESEARCH_PARENT_ID}`;
        if (this.branchCache[cacheKey]) {
          delete this.branchCache[cacheKey];
        }
      }
      
      return true;
    } catch (error) {
      console.error('删除分支项目失败', error);
      pageHelper.showError('删除分支项目失败: ' + error.message);
      return false;
    }
  }

  /**
   * 切换当前活动分支
   * @param {string} branchId - 分支ID
   * @param {Function} callback - 切换后的回调函数
   */
  switchBranch(branchId, callback) {
    if (!branchId) return;
    
    try {
      // 更新页面数据
      if (this.page && this.page.setData) {
        this.page.setData({
          currentBranchId: branchId
        });
      }
      
      // 执行回调
      if (typeof callback === 'function') {
        callback(branchId);
      }
    } catch (error) {
      console.error('切换分支失败', error);
    }
  }
}

module.exports = BranchManager;